package com.gkzf.ai.module.crm.service.product.admin;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.gkzf.ai.module.crm.config.BaseService;
import com.gkzf.ai.module.crm.controller.admin.product.vo.productMatch.ProductMatchPageReqVO;
import com.gkzf.ai.module.crm.controller.admin.product.vo.productMatch.ProductMatchRespVO;
import com.gkzf.ai.module.crm.dal.dataobject.product.ProductMatchDO;
import com.gkzf.ai.module.crm.dal.mysql.product.ProductMatchMapper;
import com.gkzf.ai.module.system.api.dept.DeptApi;
import com.gkzf.ai.module.system.api.dict.DictDataApi;
import com.gkzf.ai.module.system.api.dict.dto.DictDataRespDTO;
import com.gkzf.ai.module.system.api.user.AdminUserApi;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.util.List;
import java.util.Objects;
import java.util.Optional;

/**
 * CRM 用户匹配产品结果 Service 实现类
 *
 * @author 国科智飞
 */
@Service
@Validated
public class ProductMatchServiceImpl extends BaseService<ProductMatchDO> implements ProductMatchService {

    @Resource
    private ProductMatchMapper productMatchMapper;

    /**
     * 部门
     */
    @Resource
    private DeptApi deptApi;
    /**
     * 字典
     */
    @Resource
    private DictDataApi dictDataApi;
    /**
     * 用户
     */
    @Resource
    private AdminUserApi adminUserApi;


    @Override
    public List<ProductMatchRespVO> getProductMatchPage(ProductMatchPageReqVO pageReqVO) {
        List<ProductMatchRespVO> productMatchRespVOS = productMatchMapper.selectProductMatchPage(pageReqVO);
        List<DictDataRespDTO> cooperationInstitution = dictDataApi.getDictDataList("cooperation_institution");

        // 循环数组 将 根据合作机构的value 去遍历 字典找到对应合作机构的图标
        for (ProductMatchRespVO item : productMatchRespVOS) {
            Optional<DictDataRespDTO> found = cooperationInstitution.stream()
                    .filter(dict -> Objects.equals(dict.getValue(), item.getCooperationInstitution()))
                    .findFirst();

            if (found.isPresent()) {
                item.setCooperationInstitutionUrl(found.get().getCssClass());
            } else {
                // 可选：处理未找到的情况，比如设为空或默认值
                item.setCooperationInstitutionUrl(""); // 或者保留原值等
            }
        }
        return productMatchRespVOS;
    }



    @Override
    @Transactional(rollbackFor = Exception.class)
    public void insertProductMatch(List<ProductMatchDO> productMatchList,Long creditBasicId) {
        LambdaQueryWrapper<ProductMatchDO> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProductMatchDO::getCreditBasicId,creditBasicId);
        List<ProductMatchDO> productMatchDOList = productMatchMapper.selectList(queryWrapper);
        // 如果没有数据，则直接新增
        if(productMatchDOList.isEmpty()){
            productMatchMapper.insertBatch(productMatchList);
        }else {
            // 获取新增和删除的集合
            List<String> noVoList = productMatchList.stream().map(ProductMatchDO::getProductNo).toList();
            List<String> noDoList = productMatchDOList.stream().map(ProductMatchDO::getProductNo).toList();
            // 获取新增对象  匹配逻辑 数据库No集合中不包含传入的No集合 新增
            List<ProductMatchDO> addProductMatch = productMatchList.stream().filter(l -> !noDoList.contains(l.getProductNo())).toList();
            // 获取删除对象 匹配逻辑 传入的No集合中不包含数据库No集合 删除
            List<ProductMatchDO> deleteProductMatch = productMatchDOList.stream().filter(l -> !noVoList.contains(l.getProductNo())).toList();
            // 获取更新对象 匹配逻辑 传入的No集合和数据库No集合都包含 并将数据库中的id 填入 传入的Id 更新
            List<ProductMatchDO> updateProductMatch = productMatchList.stream().filter(l -> noDoList.contains(l.getProductNo())).toList();
            updateProductMatch.forEach(l -> l.setId(productMatchDOList.stream().filter(l1 -> l1.getProductNo().equals(l.getProductNo())).findFirst().get().getId()));
            // 批量新增和删除
            productMatchMapper.updateBatch(updateProductMatch);
            productMatchMapper.insertBatch(addProductMatch);
            productMatchMapper.deleteByIds(deleteProductMatch.stream().map(ProductMatchDO::getId).toList());
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void insertProductMatch(List<ProductMatchDO> productMatchList,String userOpenId) {
        LambdaQueryWrapper<ProductMatchDO> queryWrapper = new LambdaQueryWrapper<>();
//        queryWrapper.eq(ProductMatchDO::getUserOpenId,userOpenId);
        List<ProductMatchDO> productMatchDOList = productMatchMapper.selectList(queryWrapper);
        // 如果没有数据，则直接新增
        if(productMatchDOList.isEmpty()){
            productMatchMapper.insertBatch(productMatchList);
        }else {
            // 获取新增和删除的集合
            List<String> noVoList = productMatchList.stream().map(ProductMatchDO::getProductNo).toList();
            List<String> noDoList = productMatchDOList.stream().map(ProductMatchDO::getProductNo).toList();
            // 获取新增对象  匹配逻辑 数据库No集合中不包含传入的No集合 新增
            List<ProductMatchDO> addProductMatch = productMatchList.stream().filter(l -> !noDoList.contains(l.getProductNo())).toList();
            // 获取删除对象 匹配逻辑 传入的No集合中不包含数据库No集合 删除
            List<ProductMatchDO> deleteProductMatch = productMatchDOList.stream().filter(l -> !noVoList.contains(l.getProductNo())).toList();
            // 获取更新对象 匹配逻辑 传入的No集合和数据库No集合都包含 并将数据库中的id 填入 传入的Id 更新
            List<ProductMatchDO> updateProductMatch = productMatchList.stream().filter(l -> noDoList.contains(l.getProductNo())).toList();
            updateProductMatch.forEach(l -> l.setId(productMatchDOList.stream().filter(l1 -> l1.getProductNo().equals(l.getProductNo())).findFirst().get().getId()));
            // 批量新增和删除
            productMatchMapper.updateBatch(updateProductMatch);
            productMatchMapper.insertBatch(addProductMatch);
            productMatchMapper.deleteByIds(deleteProductMatch.stream().map(ProductMatchDO::getId).toList());
        }
    }
}